package com.zs.usc.utils;


import java.math.BigDecimal;
import java.math.RoundingMode;
import java.sql.Timestamp;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.EnumSet;

/**
 * 转换帮助类
 */
public class ConvertUtils {

    private ConvertUtils() {
    }


    private static final DecimalFormat df = new DecimalFormat("#.##########");



    /**
     * 转换为大浮点数
     *
     * @param val 要转换值
     * @return 转换结果
     */
    public static BigDecimal parseBigDecimal(String val) {
        return new BigDecimal(val);
    }

    /**
     * 是否数字字符
     *
     * @param str 要判断的字符串
     * @return 字符串是否数字
     */
    public static boolean isDigits(String str) {
        if ((str == null) || (str.length() == 0)) {
            return false;
        }
        for (int i = 0; i < str.length(); ++i) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }







    /**
     * 转换为字符串
     *
     * @param objIn 要转换的对象。objIn为null返回空字符
     * @return 转换之后的字符串
     */
    public static String parseStr(Object objIn) {
        if (objIn == null) {
            return "";
        }

        if (objIn instanceof Number) {
            Number num = (Number) objIn;
            if (objIn instanceof Double) {
                return new BigDecimal(num.doubleValue()).toEngineeringString();
            } else if (objIn instanceof Float) {
                return new BigDecimal(num.floatValue()).toEngineeringString();
            }

            return num.toString();
        }

        return objIn.toString().trim();
    }

    /**
     * 转换为整数
     *
     * @param objIn 要转换的对象。objIn为null返回null，非数字返回0
     * @return 转换之后的整数
     */
    public static Integer parseInt(Object objIn) {
        if (objIn == null) {
            return null;
        }
        try {
            return Integer.valueOf(Integer.parseInt(parseStr(objIn)));
        } catch (Exception localException) {
        }
        return Integer.valueOf(0);
    }

    /**
     * 转换为长整型数据
     *
     * @param objIn 要转换的对象
     * @return 转换之后的长整型
     */
    public static Long parseLong(Object objIn) {
        if (null == objIn) {
            return null;
        }

        return new Long(parseStr(objIn));
    }

    /**
     * 转换为浮点型数据
     *
     * @param objIn 要转换的对象，转换失败返回null
     * @return 转换之后的浮点型
     */
    public static Float parseFloat(Object objIn) {
        if (objIn == null) {
            return null;
        }
        Float flt = null;
        try {
            flt = Float.valueOf(Float.parseFloat(parseStr(objIn)));
        } catch (Exception localException) {
        }
        return flt;
    }

    /**
     * 转换double类型数据
     *
     * @param objIn 要转换的对象，转换失败返回0.0d
     * @return 转换之后的double类型
     */
    public static Double parseDbl(Object objIn) {
        Double dbl = Double.valueOf(0.0D);
        if (objIn == null) {
            return dbl;
        }
        try {
            dbl = Double.valueOf(Double.parseDouble(parseStr(objIn)));
        } catch (Exception localException) {
        }
        return dbl;
    }

    /**
     * 按精度转换成double类型
     *
     * @param objIn 要转换的对象，转换失败返回0.0d
     * @param scale 精度
     * @return 转换之后的double类型
     */
    public static Double parseDbl(Object objIn, int scale) {
        Double dbl = Double.valueOf(0.0D);
        if (objIn == null) {
            return dbl;
        }
        try {
            BigDecimal decimal = new BigDecimal(parseStr(objIn));
            if (scale >= 0) {
                decimal = decimal.setScale(scale, RoundingMode.HALF_UP);
            }
            return Double.valueOf(decimal.doubleValue());
        } catch (NumberFormatException localNumberFormatException) {
        }
        return dbl;
    }

    /**
     * double转字符串
     *
     * @param objIn       要转换的对象
     * @param scale       精度
     * @param displayZero 是否显示零
     * @return 转换之后的字符串
     */
    public static String parseDblStr(Object objIn, int scale, boolean displayZero) {
        Double num = parseDbl(objIn, scale);
        if (num == null) {
            return "";
        }
        if ((!displayZero) && (num.doubleValue() == 0.0D)) {
            return "";
        }
        return new BigDecimal(num.doubleValue()).setScale(scale, RoundingMode.HALF_UP).toPlainString();
    }

    /**
     * xml特殊字符专业
     *
     * @param obj xml字符
     * @return 转换之后的字符串
     */
    public static String encodeSafeXML(Object obj) {
        String content = parseStr(obj);
        content = content.replace("&", "&amp;");
        content = content.replace("\r", "");
        content = content.replace("\n", "");
        content = content.replace(">", "&gt;");
        content = content.replace("<", "&lt;");
        content = content.replace("'", "&apos;");
        content = content.replace("\"", "&quot;");
        content = content.replace(String.format("%s", new Object[]{Character.valueOf(' ')}), "&nbsp;");
        content = content.replace(String.format("%s", new Object[]{Character.valueOf('\t')}), "&nbsp;");
        content = content.replace(String.format("%s", new Object[]{Character.valueOf('"')}), "&quot;");
        content = content.replace(String.format("%s", new Object[]{Character.valueOf('\'')}), "&apos;");
        content = content.replace(String.format("%s", new Object[]{Character.valueOf('\r')}), "");

        return content;
    }

    /**
     * 数字数据精度设置
     *
     * @param data  要设置的对象
     * @param scale 精度
     * @return 转换之后的字符串
     */
    public static String setScale(Object data, int scale) {
        double re = parseDbl(data).doubleValue();
        return df.format(BigDecimal.valueOf(re).setScale(scale, RoundingMode.HALF_UP));
    }

    /**
     * 转换为布尔值 @parseBoolean
     *
     * @param objIn 要转换的对象，转换失败返回false
     * @return 转换之后的布尔值对象
     */
    public static boolean parseBoolean(Object objIn) {
        return parseBoolean(objIn, false);
    }

    /**
     * 转换为布尔值
     *
     * @param objIn        要转换的对象
     * @param defaultValue 转换失败返回的值
     * @return 转换之后的布尔值对象
     */
    public static boolean parseBoolean(Object objIn, boolean defaultValue) {
        boolean bRe = defaultValue;
        if (objIn == null) {
            return bRe;
        }
        try {
            bRe = Boolean.parseBoolean(parseStr(objIn));
        } catch (Exception localException) {
        }
        return bRe;
    }

    /**
     * 通过枚举名称获取对应的枚举
     *
     * @param <E>          枚举泛型
     * @param enumType     枚举类型
     * @param convertValue 需要转换的值
     * @param defaultValue 转换失败的默认值
     * @return
     */
    public static <E extends Enum<E>> E parseEnumItem(Class<E> enumType, Object convertValue, E defaultValue) {
        if (convertValue == null) {
            return defaultValue;
        }

        String convertStr = ConvertUtils.parseStr(convertValue);
        // 遍历枚举类型名称集合
        for (E item : EnumSet.allOf(enumType)) {
            if (item.toString().equals(convertStr)) {
                return item;
            }
        }

        return defaultValue;
    }
}
